#答案生成模块
import openai
import json
from typing import List, Dict
from config import OPENAI_API_KEY, DEEPSEEK_API_KEY, XINGHE_API_KEY, XINGHE_BASE_URL, OPENAI_MODEL, DEEPSEEK_MODEL, XINGHE_MODEL
from model_status import model_status
import requests
from prompt_templates import prompt_templates
from knowledge_enhancer import zhiyuan_enhancer
from performance_timer import global_timer, APITimer

class AnswerGenerator:
    def __init__(self, openai_api_key=OPENAI_API_KEY, deepseek_api_key=DEEPSEEK_API_KEY, xinghe_api_key=XINGHE_API_KEY, gemini_api_key="AIzaSyB1lMryiHH_V_7-OVT4eyuLBrHbLsigRCs"):
        self.openai_client = openai.OpenAI(api_key=openai_api_key)
        self.deepseek_client = openai.OpenAI(api_key=deepseek_api_key, base_url="https://api.deepseek.com/v1")
        self.xinghe_client = openai.OpenAI(api_key=xinghe_api_key, base_url=XINGHE_BASE_URL)
        self.gemini_api_key = gemini_api_key
        self.gemini_url = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent"
    
    def generate(self, question: str, classification: Dict, retrieved_docs: List[Dict], context: List[Dict], preferred_model: str = None) -> str:
        """生成回答，支持指定模型。如果不指定，则按顺序尝试：星河大模型、Gemini、OpenAI、DeepSeek、本地模板。"""
        # 如果是问候语，直接返回简单回复，不进行知识增强
        if classification.get('label') == 'greeting':
            return self._generate_greeting_response(question)
        
        context_info = self._build_context_info(context)
        knowledge_info = self._build_knowledge_info(retrieved_docs)
        
        # 使用新的提示词模板系统
        multimodal_prompt = prompt_templates.get_multimodal_prompt(
            classification['label'], 
            question, 
            knowledge_info, 
            context_info
        )
        
        # 如果指定了模型，尝试使用该模型，失败则回退到本地方案
        if preferred_model:
            try:
                return self._generate_with_specific_model(preferred_model, question, classification, knowledge_info, context_info, multimodal_prompt)
            except Exception as e:
                error_msg = str(e)
                print(f"指定模型 {preferred_model} 调用失败，回退到本地备用方案: {error_msg}")
                # 回退到本地备用方案
                print("使用本地备用回答生成")
                with APITimer("本地模板生成"):
                    model_status.update_status('fallback', True)
                    model_status.switch_model('fallback')
                    fallback_answer = self._generate_fallback_answer(question, classification, retrieved_docs)
                    # 使用智源研究院知识增强回答
                    enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, fallback_answer, classification)
                # 添加模型信息和计时器信息
                global_timer.add_info("使用模型", f"本地备用方案 (原选择: {self._get_model_display_name(preferred_model)})")
                enhanced_answer = f"## 🤖 使用模型: 本地备用方案\n\n> ⚠️ 注意：您选择的 **{self._get_model_display_name(preferred_model)}** 暂时不可用，已自动切换到本地备用方案。\n\n{enhanced_answer}"
                return enhanced_answer
        
        # 否则按顺序尝试各个模型
        # 1. 优先使用星河大模型
        if model_status.status['xinghe']['available']:
            try:
                # 使用提示词模板系统
                prompt_data = prompt_templates.format_prompt(
                    classification['label'], 
                    question, 
                    knowledge_info, 
                    context_info
                )
                with APITimer("星河大模型API"):
                    response = self.xinghe_client.chat.completions.create(
                        model=XINGHE_MODEL,
                        messages=[
                            {"role": "system", "content": prompt_data["system"]},
                            {"role": "user", "content": prompt_data["user"]}
                        ],
                        max_tokens=2000,
                        temperature=0.7
                    )
                model_status.update_status('xinghe', True)
                model_status.switch_model('xinghe')
                answer = response.choices[0].message.content
                # 使用智源研究院知识增强回答
                with APITimer("星河知识增强"):
                    enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, answer, classification)
                # 添加模型信息和计时器信息
                global_timer.add_info("使用模型", f"星河大模型 ({model_status.status['xinghe']['model']})")
                enhanced_answer = f"## 🤖 使用模型: 星河大模型 ({model_status.status['xinghe']['model']})\n\n{enhanced_answer}"
                return enhanced_answer
            except Exception as e:
                error_msg = str(e)
                print(f"星河大模型API调用失败: {error_msg}")
                model_status.update_status('xinghe', False, error_msg)
                global_timer.add_info("星河错误", error_msg[:100])
        
        # 2. 使用Gemini
        try:
            gemini_payload = {
                "contents": [
                    {"parts": [
                        {"text": multimodal_prompt}
                    ]}
                ]
            }
            headers = {
                "Content-Type": "application/json",
                "X-goog-api-key": self.gemini_api_key
            }
            with APITimer("Gemini模型API"):
                resp = requests.post(self.gemini_url, json=gemini_payload, headers=headers, timeout=30)
            if resp.status_code == 200:
                data = resp.json()
                # Gemini返回格式兼容Markdown
                if "candidates" in data and data["candidates"]:
                    content = data["candidates"][0]["content"]["parts"][0]["text"]
                    model_status.update_status('gemini', True)
                    model_status.switch_model('gemini')
                    # 使用智源研究院知识增强回答
                    with APITimer("Gemini知识增强"):
                        enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, content, classification)
                    # 添加模型信息和计时器信息
                    global_timer.add_info("使用模型", "Gemini")
                    enhanced_answer = f"## 🤖 使用模型: Gemini\n\n{enhanced_answer}"
                    return enhanced_answer
                else:
                    raise Exception("Gemini无有效回答")
            else:
                raise Exception(f"Gemini API错误: {resp.status_code} {resp.text}")
        except Exception as e:
            error_msg = str(e)
            print(f"Gemini API调用失败: {error_msg}")
            model_status.update_status('gemini', False, error_msg)
            global_timer.add_info("Gemini错误", error_msg[:100])
        
        # 3. 尝试使用OpenAI
        if model_status.status['openai']['available']:
            try:
                # 使用提示词模板系统
                prompt_data = prompt_templates.format_prompt(
                    classification['label'], 
                    question, 
                    knowledge_info, 
                    context_info
                )
                with APITimer("OpenAI模型API"):
                    response = self.openai_client.chat.completions.create(
                        model=OPENAI_MODEL,
                        messages=[
                            {"role": "system", "content": prompt_data["system"]},
                            {"role": "user", "content": prompt_data["user"]}
                        ],
                        max_tokens=2000,
                        temperature=0.7
                    )
                model_status.update_status('openai', True)
                model_status.switch_model('openai')
                answer = response.choices[0].message.content
                # 使用智源研究院知识增强回答
                with APITimer("OpenAI知识增强"):
                    enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, answer, classification)
                # 添加模型信息和计时器信息
                global_timer.add_info("使用模型", f"OpenAI ({model_status.status['openai']['model']})")
                enhanced_answer = f"## 🤖 使用模型: OpenAI ({model_status.status['openai']['model']})\n\n{enhanced_answer}"
                return enhanced_answer
            except Exception as e:
                error_msg = str(e)
                print(f"OpenAI API调用失败: {error_msg}")
                model_status.update_status('openai', False, error_msg)
                global_timer.add_info("OpenAI错误", error_msg[:100])
        
        # 4. 尝试使用DeepSeek
        if model_status.status['deepseek']['available']:
            try:
                # 使用提示词模板系统
                prompt_data = prompt_templates.format_prompt(
                    classification['label'], 
                    question, 
                    knowledge_info, 
                    context_info
                )
                with APITimer("DeepSeek模型API"):
                    response = self.deepseek_client.chat.completions.create(
                        model=DEEPSEEK_MODEL,
                        messages=[
                            {"role": "system", "content": prompt_data["system"]},
                            {"role": "user", "content": prompt_data["user"]}
                        ],
                        max_tokens=2000,
                        temperature=0.7
                    )
                model_status.update_status('deepseek', True)
                model_status.switch_model('deepseek')
                answer = response.choices[0].message.content
                # 使用智源研究院知识增强回答
                with APITimer("DeepSeek知识增强"):
                    enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, answer, classification)
                # 添加模型信息和计时器信息
                global_timer.add_info("使用模型", f"DeepSeek ({model_status.status['deepseek']['model']})")
                enhanced_answer = f"## 🤖 使用模型: DeepSeek ({model_status.status['deepseek']['model']})\n\n{enhanced_answer}"
                return enhanced_answer
            except Exception as e2:
                error_msg = str(e2)
                print(f"DeepSeek API调用失败: {error_msg}")
                model_status.update_status('deepseek', False, error_msg)
                global_timer.add_info("DeepSeek错误", error_msg[:100])
        # 5. 本地模板
        print("使用本地备用回答生成")
        with APITimer("本地模板生成"):
            model_status.update_status('fallback', True)
            model_status.switch_model('fallback')
            fallback_answer = self._generate_fallback_answer(question, classification, retrieved_docs)
            # 使用智源研究院知识增强回答
            enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, fallback_answer, classification)
        # 添加模型信息和计时器信息
        global_timer.add_info("使用模型", "本地备用方案")
        enhanced_answer = f"## 🤖 使用模型: 本地备用方案\n\n{enhanced_answer}"
        return enhanced_answer
    
    def _generate_with_specific_model(self, model_name: str, question: str, classification: Dict, knowledge_info: str, context_info: str, multimodal_prompt: str) -> str:
        """使用指定的模型生成回答"""
        # 星河大模型
        if model_name == 'xinghe':
            # 即使状态为不可用，也尝试调用（可能是状态更新不及时）
            try:
                prompt_data = prompt_templates.format_prompt(
                    classification['label'], 
                    question, 
                    knowledge_info, 
                    context_info
                )
                with APITimer("星河大模型API"):
                    response = self.xinghe_client.chat.completions.create(
                        model=XINGHE_MODEL,
                        messages=[
                            {"role": "system", "content": prompt_data["system"]},
                            {"role": "user", "content": prompt_data["user"]}
                        ],
                        max_tokens=2000,
                        temperature=0.7
                    )
                model_status.update_status('xinghe', True)
                model_status.switch_model('xinghe')
                answer = response.choices[0].message.content
                with APITimer("星河知识增强"):
                    enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, answer, classification)
                global_timer.add_info("使用模型", f"星河大模型 ({model_status.status['xinghe']['model']})")
                enhanced_answer = f"## 🤖 使用模型: 星河大模型 ({model_status.status['xinghe']['model']})\n\n{enhanced_answer}"
                return enhanced_answer
            except Exception as e:
                error_msg = str(e)
                print(f"星河大模型API调用失败: {error_msg}")
                model_status.update_status('xinghe', False, error_msg)
                raise Exception(f"星河大模型调用失败: {error_msg}")
        
        # Gemini模型
        elif model_name == 'gemini':
            try:
                gemini_payload = {
                    "contents": [
                        {"parts": [
                            {"text": multimodal_prompt}
                        ]}
                    ]
                }
                headers = {
                    "Content-Type": "application/json",
                    "X-goog-api-key": self.gemini_api_key
                }
                with APITimer("Gemini模型API"):
                    resp = requests.post(self.gemini_url, json=gemini_payload, headers=headers, timeout=30)
                if resp.status_code == 200:
                    data = resp.json()
                    if "candidates" in data and data["candidates"]:
                        content = data["candidates"][0]["content"]["parts"][0]["text"]
                        model_status.update_status('gemini', True)
                        model_status.switch_model('gemini')
                        with APITimer("Gemini知识增强"):
                            enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, content, classification)
                        global_timer.add_info("使用模型", "Gemini")
                        enhanced_answer = f"## 🤖 使用模型: Gemini\n\n{enhanced_answer}"
                        return enhanced_answer
                    else:
                        raise Exception("Gemini无有效回答")
                else:
                    raise Exception(f"Gemini API错误: {resp.status_code} {resp.text}")
            except Exception as e:
                error_msg = str(e)
                print(f"Gemini API调用失败: {error_msg}")
                model_status.update_status('gemini', False, error_msg)
                raise Exception(f"Gemini模型调用失败: {error_msg}")
        
        # OpenAI模型
        elif model_name == 'openai':
            # 即使状态为不可用，也尝试调用（可能是状态更新不及时）
            try:
                prompt_data = prompt_templates.format_prompt(
                    classification['label'], 
                    question, 
                    knowledge_info, 
                    context_info
                )
                with APITimer("OpenAI模型API"):
                    response = self.openai_client.chat.completions.create(
                        model=OPENAI_MODEL,
                        messages=[
                            {"role": "system", "content": prompt_data["system"]},
                            {"role": "user", "content": prompt_data["user"]}
                        ],
                        max_tokens=2000,
                        temperature=0.7
                    )
                model_status.update_status('openai', True)
                model_status.switch_model('openai')
                answer = response.choices[0].message.content
                with APITimer("OpenAI知识增强"):
                    enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, answer, classification)
                global_timer.add_info("使用模型", f"OpenAI ({model_status.status['openai']['model']})")
                enhanced_answer = f"## 🤖 使用模型: OpenAI ({model_status.status['openai']['model']})\n\n{enhanced_answer}"
                return enhanced_answer
            except Exception as e:
                error_msg = str(e)
                print(f"OpenAI API调用失败: {error_msg}")
                model_status.update_status('openai', False, error_msg)
                raise Exception(f"OpenAI模型调用失败: {error_msg}")
        
        # DeepSeek模型
        elif model_name == 'deepseek':
            # 即使状态为不可用，也尝试调用（可能是状态更新不及时）
            try:
                prompt_data = prompt_templates.format_prompt(
                    classification['label'], 
                    question, 
                    knowledge_info, 
                    context_info
                )
                with APITimer("DeepSeek模型API"):
                    response = self.deepseek_client.chat.completions.create(
                        model=DEEPSEEK_MODEL,
                        messages=[
                            {"role": "system", "content": prompt_data["system"]},
                            {"role": "user", "content": prompt_data["user"]}
                        ],
                        max_tokens=2000,
                        temperature=0.7
                    )
                model_status.update_status('deepseek', True)
                model_status.switch_model('deepseek')
                answer = response.choices[0].message.content
                with APITimer("DeepSeek知识增强"):
                    enhanced_answer = zhiyuan_enhancer.enhance_answer_with_knowledge(question, answer, classification)
                global_timer.add_info("使用模型", f"DeepSeek ({model_status.status['deepseek']['model']})")
                enhanced_answer = f"## 🤖 使用模型: DeepSeek ({model_status.status['deepseek']['model']})\n\n{enhanced_answer}"
                return enhanced_answer
            except Exception as e:
                error_msg = str(e)
                print(f"DeepSeek API调用失败: {error_msg}")
                model_status.update_status('deepseek', False, error_msg)
                raise Exception(f"DeepSeek模型调用失败: {error_msg}")
        
        else:
            raise Exception(f"未知的模型名称: {model_name}")
    
    def _get_model_display_name(self, model_name: str) -> str:
        """获取模型的显示名称"""
        model_names = {
            'xinghe': '星河大模型',
            'gemini': 'Gemini',
            'openai': 'OpenAI',
            'deepseek': 'DeepSeek'
        }
        return model_names.get(model_name, model_name)
    
    def _generate_greeting_response(self, question: str) -> str:
        """生成问候语回复"""
        greeting_responses = [
            """# 👋 你好！

很高兴见到你！我是你的Rust编程学习助手。

## 🦀 我能为你做什么？

**Rust知识解答**：
- 解释Rust概念和语法
- 提供代码示例和最佳实践
- 协助调试和错误解决
- 回答编程相关问题

## 💡 开始学习

有什么Rust相关的问题想要了解吗？比如：
- "什么是所有权？"
- "如何使用Vec？"
- "生命周期是什么？"

随时提问，我会尽力帮助你！""",
            
            """# 🌟 欢迎！

你好！我是专业的Rust编程助手。

## 🚀 服务特色

**智能问答**：基于星河大模型的专业回答
**知识增强**：结合智源研究院最新研究成果
**多模态输出**：支持代码高亮、图表、表格
**在线编程**：Monaco Editor集成，支持代码运行

## 🎯 开始探索

准备好开始你的Rust学习之旅了吗？有什么问题尽管问我！""",
            
            """# 🦀 Hello Rust!

很高兴认识你！我是你的Rust学习伙伴。

## 💪 我的能力

- **概念解释**：深入浅出地解释Rust概念
- **代码示例**：提供实用的代码示例
- **错误调试**：帮助解决编译和运行时问题
- **最佳实践**：分享Rust编程的最佳实践

## 🔥 立即开始

有什么Rust问题想要了解？我在这里等你！"""
        ]
        
        # 根据问题内容选择不同的回复
        question_lower = question.lower()
        if 'hello' in question_lower or 'hi' in question_lower:
            return greeting_responses[0]
        elif '你好' in question_lower:
            return greeting_responses[1]
        else:
            return greeting_responses[2]
    
    def _build_context_info(self, context: List[Dict]) -> str:
        """构建上下文信息"""
        if not context:
            return ""
        
        context_info = "**对话历史：**\n"
        for i, turn in enumerate(context[-3:], 1):  # 只保留最近3轮
            context_info += f"{i}. 问：{turn['question']}\n   答：{turn['answer'][:100]}...\n\n"
        return context_info
    
    def _build_knowledge_info(self, docs: List[Dict]) -> str:
        """构建知识库信息"""
        if not docs:
            return "**相关知识点：** 未找到相关知识\n"
        
        knowledge_info = "**相关知识点：**\n"
        for doc in docs:
            knowledge_info += f"- **{doc['topic']}**：{doc['content']}\n"
            if 'code' in doc:
                knowledge_info += f"  ```rust\n  {doc['code']}\n  ```\n"
        return knowledge_info
    

    
    def _is_non_rust_question(self, question: str) -> bool:
        """判断是否为非Rust相关问题"""
        question_lower = question.lower()
        
        # 定义Rust相关关键词
        rust_keywords = [
            'rust', '生命周期', '所有权', '借用', '可变', '不可变', 'trait', 'struct', 'enum',
            'match', 'option', 'result', '迭代器', '闭包', '宏', '模块', 'cargo', '编译',
            '错误', '调试', '内存', '安全', '并发', '异步', 'future', 'pin', 'unsafe'
        ]
        
        # 定义通用问候语
        greetings = ['你好', 'hello', 'hi', '您好', '早上好', '下午好', '晚上好', '嗨']
        
        # 如果是问候语，直接返回True
        if any(greeting in question_lower for greeting in greetings):
            return True
        
        # 检查是否包含Rust相关关键词
        has_rust_keywords = any(keyword in question_lower for keyword in rust_keywords)
        
        # 如果没有Rust关键词，可能是非Rust问题
        return not has_rust_keywords
    
    def _generate_general_response(self, question: str) -> str:
        """生成通用回答（非Rust相关问题）"""
        question_lower = question.lower()
        
        # 问候语回答
        if any(greeting in question_lower for greeting in ['你好', 'hello', 'hi', '您好', '早上好', '下午好', '晚上好', '嗨']):
            return """## 您好！ 👋

很高兴见到您！我是**Rust知识解释智能体**，专门帮助您学习Rust编程语言。

### 🤖 我能为您做什么？
- **概念解释**：解释Rust的核心概念，如所有权、生命周期等
- **用法指导**：提供代码示例和最佳实践
- **错误调试**：帮助解决编译和运行时错误
- **语言对比**：比较Rust与其他编程语言的异同
- **学习建议**：提供Rust学习路径和资源推荐

### 💡 试试这些Rust相关问题：
- "Rust的所有权是什么？"
- "如何使用迭代器？"
- "这个编译错误怎么解决？"
- "Rust和C++有什么区别？"
- "如何学习Rust？"

### 🚀 开始探索Rust世界
请在下方输入您的Rust相关问题，我会为您提供详细的解答！

### 🔧 代码编辑器
想要实践代码？点击这里进入 <a href="http://127.0.0.1:5000/code_editor" target="_blank"><b>代码编辑器</b></a> 进行在线编程练习！"""
        
        # 其他非Rust问题的回答
        return f"""## 关于"{question}"的回复 🤔

我注意到您的问题可能不是关于Rust编程的。我是**Rust知识解释智能体**，专门帮助用户学习Rust编程语言。

### 🎯 我的专长领域
- **Rust编程概念**：所有权、生命周期、借用检查器等
- **Rust语法和用法**：变量、函数、结构体、枚举等
- **Rust错误调试**：编译错误、运行时错误等
- **Rust最佳实践**：代码组织、性能优化等

### 💡 如果您想了解Rust，可以试试：
- "Rust是什么？"
- "Rust适合什么项目？"
- "如何开始学习Rust？"
- "Rust有什么特点？"

### 🔗 其他资源
如果您需要其他方面的帮助，建议您：
- 使用专门的搜索引擎
- 访问相关领域的专业网站
- 咨询相关领域的专家

        我很乐意继续为您提供Rust编程方面的帮助！ 🦀"""
    
    def _generate_fallback_answer(self, question: str, classification: Dict, retrieved_docs: List[Dict]) -> str:
        """生成备用回答（当API调用失败时）"""
        question_lower = question.lower()
        
        # 根据问题类型生成不同的回答
        if classification['label'] == 'definition':
            return self._generate_definition_fallback(question)
        elif classification['label'] == 'usage':
            return self._generate_usage_fallback(question)
        elif classification['label'] == 'error_debug':
            return self._generate_error_debug_fallback(question)
        elif classification['label'] == 'comparison':
            return self._generate_comparison_fallback(question)
        else:
            return self._generate_faq_fallback(question)
    
    def _generate_definition_fallback(self, question: str) -> str:
        """生成定义类问题的备用回答，代码练习和综合案例根据用户问题动态生成"""
        # 动态生成代码练习题
        code_ex1 = f"练习1：请编写一个函数，演示“{question}”相关的基本用法。"
        code_ex2 = f"练习2：请实现一个结构体或算法，体现“{question}”的核心特性。"
        # 动态生成综合案例
        case_req = f"案例要求：设计一个小项目，要求充分体现“{question}”的实际应用场景。"
        case_steps = f"实现步骤：1. 明确项目目标和输入输出；2. 设计主要数据结构和函数；3. 实现核心功能；4. 编写测试用例验证。"
        return f"""
<div class=\"system-section\">
  <div class=\"system-section-title\"><i class=\"fas fa-book\"></i> 概念定义</div>
  <ol class=\"system-section-list\">
    <li><strong>{question.replace('是什么', '').replace('？', '').replace('什么意思', '')}</strong>是Rust编程语言中的一个重要概念。</li>
    <li>这是Rust的核心特性之一</li>
    <li>确保内存安全和线程安全</li>
    <li>编译时检查，运行时零开销</li>
    <li>提供强大的抽象能力</li>
  </ol>
  <div class=\"system-section-title\"><i class=\"fas fa-code\"></i> 代码练习</div>
  <ol class=\"system-section-list\">
    <li>{code_ex1}</li>
    <li>{code_ex2}</li>
  </ol>
  <div class=\"system-section-title\"><i class=\"fas fa-lightbulb\"></i> 综合案例</div>
  <ol class=\"system-section-list\">
    <li>{case_req}</li>
    <li>{case_steps}</li>
  </ol>
  <div class=\"system-section-title\"><i class=\"fas fa-edit\"></i> 实践练习</div>
  <p>想要实践这些代码练习？点击这里进入 <a href="http://127.0.0.1:5000/code_editor" target="_blank"><b>代码编辑器</b></a> 进行在线编程！</p>
</div>
"""
    
    def _generate_usage_fallback(self, question: str) -> str:
        """生成用法类问题的备用回答"""
        return f"""## 基本用法

以下是**{question.replace('怎么', '').replace('如何', '').replace('使用', '').replace('？', '')}**的基本用法：

### 代码示例
```rust
fn main() {{
    // 基本用法示例
    let result = example_function();
    println!("结果: {{}}", result);
}}

fn example_function() -> i32 {{
    42
}}
```

### 参数说明
- param1: 第一个参数的作用
- param2: 第二个参数的作用

### 最佳实践
1. 遵循Rust的命名约定
2. 使用适当的错误处理
3. 考虑性能影响
4. 编写清晰的文档

### 常见用法
- 基本语法
- 函数调用
- 错误处理
- 模块组织

### 🔧 实践练习
想要运行这些代码示例？点击这里进入 <a href="http://127.0.0.1:5000/code_editor" target="_blank"><b>代码编辑器</b></a> 进行在线编程练习！"""
    
    def _generate_error_debug_fallback(self, question: str) -> str:
        """生成错误调试类问题的备用回答"""
        return f"""## 错误分析

您遇到的**{question.replace('错误', '').replace('问题', '').replace('？', '')}**通常是由于以下原因：

### 常见原因
- 借用检查器规则违反
- 生命周期不匹配
- 类型不匹配
- 所有权问题

### 解决方案
```rust
// 错误代码示例
let mut v = vec![1, 2, 3];
let first = &v[0];
v.push(4); // 编译错误

// 正确代码
let mut v = vec![1, 2, 3];
v.push(4);
let first = &v[0]; // 正确
```

### 调试技巧
1. 仔细阅读编译器错误信息
2. 使用 `cargo check` 进行静态检查
3. 逐步简化代码定位问题
4. 查看官方文档和示例

### 预防措施
- 理解所有权规则
- 注意生命周期
- 合理使用借用
- 编写测试代码

### 🔧 调试练习
想要实践这些调试技巧？点击这里进入 <a href="http://127.0.0.1:5000/code_editor" target="_blank"><b>代码编辑器</b></a> 进行在线调试练习！"""
    
    def _generate_comparison_fallback(self, question: str) -> str:
        """生成对比类问题的备用回答"""
        return f"""## 对比分析

**{question.replace('区别', '').replace('不同', '').replace('比较', '').replace('？', '')}**的主要差异：

### 核心差异
| 特性 | Rust | 其他语言 |
|------|------|----------|
| 内存管理 | 所有权系统 | 垃圾回收/手动管理 |
| 并发安全 | 编译时检查 | 运行时检查 |
| 性能 | 零开销抽象 | 可能有运行时开销 |
| 学习曲线 | 较陡峭 | 相对平缓 |

### 代码对比
```rust
// Rust 示例
let s = String::from("hello");
// 所有权自动管理
```

```cpp
// C++ 示例
std::string s = "hello";
// 需要手动管理内存
```

### 适用场景
- **Rust**: 系统编程、性能敏感应用、安全关键系统
- **其他**: 快速原型、脚本编程、通用应用开发

### 选择建议
- 需要内存安全：选择Rust
- 需要快速开发：选择其他语言
- 需要高性能：Rust是很好的选择

### 🔧 实践对比
想要亲自体验Rust的特性？点击这里进入 <a href="http://127.0.0.1:5000/code_editor" target="_blank"><b>代码编辑器</b></a> 进行在线编程实践！"""
    
    def _generate_faq_fallback(self, question: str) -> str:
        """生成FAQ类问题的备用回答"""
        return f"""## 问题解答

关于**{question.replace('？', '')}**的详细解答：

### 背景说明
这是一个常见的问题，涉及到Rust的学习路径和最佳实践。

### 实践建议
1. 从官方文档开始学习
2. 多做练习项目
3. 参与社区讨论
4. 阅读优秀代码

### 学习资源
- [Rust官方文档](https://doc.rust-lang.org/)
- [Rust Book](https://doc.rust-lang.org/book/)
- [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
- [Rust社区](https://users.rust-lang.org/)

### 扩展阅读
- 所有权系统详解
- 生命周期管理
- 错误处理最佳实践
- 并发编程模式

### 学习路径
1. 基础语法
2. 所有权和借用
3. 错误处理
4. 高级特性
5. 项目实践

### 🔧 开始实践
想要开始Rust编程实践？点击这里进入 <a href="http://127.0.0.1:5000/code_editor" target="_blank"><b>代码编辑器</b></a> 进行在线编程学习！"""